home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / MPW Oberon 2.1168 / OInterfaces / Quickdraw.mod < prev    next >
Encoding:
Text File  |  1995-08-10  |  55.6 KB  |  1,760 lines  |  [TEXT/MPS ]
  1. (*
  2.      File:        Quickdraw.mod
  3.  
  4.      Contains:    QuickDraw Graphics Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs.applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. *)
  19.  
  20. (*$IF UNDEFINED OLDROUTINELOCATIONS*)
  21.   (*$SET OLDROUTINELOCATIONS FALSE*)
  22. (*$END*)
  23. (*$IF UNDEFINED OLDROUTINENAMES*)
  24.   (*$SET OLDROUTINENAMES FALSE*)
  25. (*$END*)
  26. (*$IF UNDEFINED SystemSevenFiveOrLater *)
  27.   (*$SET SystemSevenFiveOrLater FALSE*)
  28. (*$END*)
  29. (*$IF UNDEFINED SystemSevenOrLater *)
  30.   (*$IF GENERATINGCFM *)
  31.     (*$SET SystemSevenOrLater TRUE*)
  32.   (*$ELSE*)
  33.     (*$SET SystemSevenOrLater SystemSevenFiveOrLater*)
  34.   (*$END*)
  35. (*$END*)
  36. (*$IF UNDEFINED SystemSixOrLater *)
  37.   (*$SET SystemSixOrLater SystemSevenOrLater*)
  38. (*$END*)
  39. (*$TAGS-*)
  40. (*$CALLING PASCAL*)
  41. MODULE Quickdraw;
  42.  
  43. IMPORT SYSTEM, Types, QuickdrawText;
  44.  
  45. (* $PUSH*)
  46. (* $ALIGN MAC68K*)
  47. (* $LibExport+*)
  48.  
  49. CONST
  50.     invalColReq*                    = -1;                            (*invalid color table request*)
  51. (* transfer modes *)
  52.     srcCopy*                        = 0;                            (*the 16 transfer modes*)
  53.     srcOr*                        = 1;
  54.     srcXor*                        = 2;
  55.     srcBic*                        = 3;
  56.     notSrcCopy*                    = 4;
  57.     notSrcOr*                    = 5;
  58.     notSrcXor*                    = 6;
  59.     notSrcBic*                    = 7;
  60.     patCopy*                        = 8;
  61.     patOr*                        = 9;
  62.     patXor*                        = 10;
  63.     patBic*                        = 11;
  64.     notPatCopy*                    = 12;
  65.     notPatOr*                    = 13;
  66.     notPatXor*                    = 14;
  67.     notPatBic*                    = 15;
  68. (* Special Text Transfer Mode *)
  69.     grayishTextOr*                = 49;
  70.     hilitetransfermode*            = 50;
  71. (* Arithmetic transfer modes *)
  72.     blend*                        = 32;
  73.     addPin*                        = 33;
  74.  
  75.     addOver*                        = 34;
  76.     subPin*                        = 35;
  77.     addMax*                        = 37;
  78.     adMax*                        = 37;
  79.     subOver*                        = 38;
  80.     adMin*                        = 39;
  81.     ditherCopy*                    = 64;
  82. (* Transparent mode constant *)
  83.     transparent*                    = 36;
  84.     italicBit*                    = 1;
  85.     ulineBit*                    = 2;
  86.     outlineBit*                    = 3;
  87.     shadowBit*                    = 4;
  88.     condenseBit*                    = 5;
  89.     extendBit*                    = 6;
  90. (* QuickDraw color separation constants *)
  91.     normalBit*                    = 0;                            (*normal screen mapping*)
  92.     inverseBit*                    = 1;                            (*inverse screen mapping*)
  93.     redBit*                        = 4;                            (*RGB additive mapping*)
  94.     greenBit*                    = 3;
  95.     blueBit*                        = 2;
  96.     cyanBit*                        = 8;                            (*CMYBk subtractive mapping*)
  97.     magentaBit*                    = 7;
  98.     yellowBit*                    = 6;
  99.     blackBit*                    = 5;
  100.     blackColor*                    = 33;                            (*colors expressed in these mappings*)
  101.     whiteColor*                    = 30;
  102.     redColor*                    = 205;
  103.  
  104.     greenColor*                    = 341;
  105.     blueColor*                    = 409;
  106.     cyanColor*                    = 273;
  107.     magentaColor*                = 137;
  108.     yellowColor*                    = 69;
  109.     picLParen*                    = 0;                            (*standard picture comments*)
  110.     picRParen*                    = 1;
  111.     clutType*                    = 0;                            (*0 if lookup table*)
  112.     fixedType*                    = 1;                            (*1 if fixed table*)
  113.     directType*                    = 2;                            (*2 if direct values*)
  114.     gdDevType*                    = 0;                            (*0* = monochrome 1* = color*)
  115.  
  116.     roundedDevice*                = 5;                            (* 1 if device has been “rounded” into the GrayRgn *)
  117.     hasAuxMenuBar*                = 6;                            (* 1 if device has an aux menu bar on it *)
  118.     burstDevice*                    = 7;
  119.     ext32Device*                    = 8;
  120.     ramInit*                        = 10;                            (*1 if initialized from LONG("scrn") resource*)
  121.     mainScreen*                    = 11;                            (* 1 if main screen *)
  122.     allInit*                        = 12;                            (* 1 if all devices initialized *)
  123.     screenDevice*                = 13;                            (*1 if screen device [not used]*)
  124.     noDriver*                    = 14;                            (* 1 if no driver for this GDevice *)
  125.     screenActive*                = 15;                            (*1 if in use*)
  126.     hiliteBit*                    = 7;                            (*flag bit in HiliteMode (lowMem flag)*)
  127.     pHiliteBit*                    = 0;                            (*flag bit in HiliteMode used with BitClr procedure*)
  128.     defQDColors*                    = 127;                            (*resource AIFF.ID of clut for default QDColors*)
  129. (* pixel type *)
  130.     RGBDirect*                    = 16;                            (* 16 & 32 bits/pixel pixelType value *)
  131. (* pmVersion values *)
  132.     baseAddr32*                    = 4;                            (*pixmap base address is 32-bit address*)
  133.  
  134.     frame*                        = 0;
  135.     paint*                        = 1;
  136.     erase*                        = 2;
  137.     invert*                        = 3;
  138.     fill*                        = 4;
  139.  
  140.     
  141. TYPE
  142.     GrafVerb* = Types.SInt8;
  143.  
  144.  
  145. CONST
  146.     chunky*                        = 0;
  147.     chunkyPlanar*                = 1;
  148.     planar*                        = 2;
  149.  
  150.     
  151. TYPE
  152.     PixelType* = Types.SInt8;
  153.  
  154.     Bits16* = ARRAY 16 (*ΔΔ[0..15]ΔΔ*) OF INTEGER;
  155.  
  156. (***************   IMPORTANT NOTE REGARDING Pattern  **************************************
  157.    Patterns were originally defined as*:
  158.    
  159.         C*:             typedef unsigned char Pattern[8];
  160.         Pascal*:        Pattern* = (*ΔΔPACKEDΔΔ*) ARRAY [0..7] OF 0..255;
  161.         
  162.    The old array defintion of Pattern would cause 68000 based CPU's to crash in certain circum-
  163.    stances. The new struct definition is safe, but may require source code changes to compile.
  164.    Read the details in TechNote "Platforms & Tools" #PT 38.
  165.     
  166. *********************************************************************************************)
  167.     Pattern* = RECORD
  168.         pat*:                    (*ΔΔ (*ΔΔPACKEDΔΔ*)*) ARRAY 8 (*ΔΔ[0..7]ΔΔ*) OF Types.SInt8; (* UInt8 *)
  169.     END;
  170.  
  171. (*
  172.  ConstPatternParam is now longer needed.  It was first created when Pattern was an array.
  173.  Now that Pattern is a struct, it is more straight forward just add the "const" qualifier
  174.  on the parameter type (e.g. "const Pattern * pat" instead of "ConstPatternParam pat").
  175. *)
  176.     PatPtr* = POINTER TO Pattern;
  177.  
  178.     PatHandle* = HANDLE TO Pattern (*ΔΔ POINTER TO PatPtr*);
  179.  
  180.     QDByte* = Types.SignedByte;
  181.  
  182.     QDPtr* = Types.Ptr;
  183.  
  184.     QDHandle* = Types.Handle;
  185.  
  186.     QDErr* = INTEGER;
  187.  
  188.  
  189. CONST
  190.     singleDevicesBit*            = 0;
  191.     dontMatchSeedsBit*            = 1;
  192.     allDevicesBit*                = 2;
  193.  
  194.     singleDevices*                = ASH(1,singleDevicesBit);
  195.     dontMatchSeeds*                = ASH(1,dontMatchSeedsBit);
  196.     allDevices*                    = ASH(1,allDevicesBit);
  197.  
  198.     
  199. TYPE
  200.     DeviceLoopFlags* = LONGINT;
  201.  
  202.     BitMap* = RECORD
  203.         baseAddr*:                Types.Ptr;
  204.         rowBytes*:                INTEGER;
  205.         bounds*:                    Types.Rect;
  206.     END;
  207.  
  208.     BitMapPtr* = POINTER TO BitMap;
  209.     BitMapHandle* = HANDLE TO BitMap (*ΔΔ POINTER TO BitMapPtr*);
  210.  
  211.     Cursor* = RECORD
  212.         data*:                    Bits16;
  213.         mask*:                    Bits16;
  214.         hotSpot*:                Types.Point;
  215.     END;
  216.  
  217.     CursPtr* = POINTER TO Cursor;
  218.     CursHandle* = HANDLE TO Cursor (*ΔΔ POINTER TO CursPtr*);
  219.  
  220.     PenState* = RECORD
  221.         pnLoc*:                    Types.Point;
  222.         pnSize*:                    Types.Point;
  223.         pnMode*:                    INTEGER;
  224.         pnPat*:                    Pattern;
  225.     END;
  226.  
  227.     Region* = RECORD
  228.         rgnSize*:                INTEGER;                                (*size in bytes*)
  229.         rgnBBox*:                Types.Rect;                                    (*enclosing rectangle*)
  230.     END;
  231.  
  232.     RgnPtr* = POINTER TO Region;
  233.     RgnHandle* = HANDLE TO Region (*ΔΔ POINTER TO RgnPtr*);
  234.  
  235.     Picture* = RECORD
  236.         picSize*:                INTEGER;
  237.         picFrame*:                Types.Rect;
  238.     END;
  239.  
  240.     PicPtr* = POINTER TO Picture;
  241.     PicHandle* = HANDLE TO Picture (*ΔΔ POINTER TO PicPtr*);
  242.  
  243.     Polygon* = RECORD
  244.         polySize*:                INTEGER;
  245.         polyBBox*:                Types.Rect;
  246.         polyPoints*:                ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF Types.Point;
  247.     END;
  248.  
  249.     PolyPtr* = POINTER TO Polygon;
  250.     PolyHandle* = HANDLE TO Polygon (*ΔΔ POINTER TO PolyPtr*);
  251.  
  252.     QDTextProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (byteCount: INTEGER; textBuf: Types.Ptr; numer: Types.Point; denom: Types.Point);
  253.     QDLineProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (newPt: Types.Point);
  254.     QDRectProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (verb: Types.ByteParameter; VAR r: Types.Rect);
  255.     QDRRectProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (verb: Types.ByteParameter; VAR r: Types.Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  256.     QDOvalProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (verb: Types.ByteParameter; VAR r: Types.Rect);
  257.     QDArcProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (verb: Types.ByteParameter; VAR r: Types.Rect; startAngle: INTEGER; arcAngle: INTEGER);
  258.     QDPolyProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (verb: Types.ByteParameter; poly: PolyHandle);
  259.     QDRgnProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (verb: Types.ByteParameter; rgn: RgnHandle);
  260.     QDBitsProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR srcBits: BitMap; VAR srcRect: Types.Rect; VAR dstRect: Types.Rect; mode: INTEGER; maskRgn: RgnHandle);
  261.     QDCommentProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (kind: INTEGER; dataSize: INTEGER; dataHandle: Types.Handle);
  262.     QDTxMeasProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (byteCount: INTEGER; textAddr: Types.Ptr; VAR numer: Types.Point; VAR denom: Types.Point; VAR info: QuickdrawText.FontInfo): INTEGER;
  263.     QDGetPicProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (dataPtr: Types.Ptr; byteCount: INTEGER);
  264.     QDPutPicProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (dataPtr: Types.Ptr; byteCount: INTEGER);
  265.     QDOpcodeProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR fromRect: Types.Rect; VAR toRect: Types.Rect; opcode: INTEGER; version: INTEGER);
  266.     QDJShieldCursorProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  267.     QDTextUPP* = Types.UniversalProcPtr;
  268.     QDLineUPP* = Types.UniversalProcPtr;
  269.     QDRectUPP* = Types.UniversalProcPtr;
  270.     QDRRectUPP* = Types.UniversalProcPtr;
  271.     QDOvalUPP* = Types.UniversalProcPtr;
  272.     QDArcUPP* = Types.UniversalProcPtr;
  273.     QDPolyUPP* = Types.UniversalProcPtr;
  274.     QDRgnUPP* = Types.UniversalProcPtr;
  275.     QDBitsUPP* = Types.UniversalProcPtr;
  276.     QDCommentUPP* = Types.UniversalProcPtr;
  277.     QDTxMeasUPP* = Types.UniversalProcPtr;
  278.     QDGetPicUPP* = Types.UniversalProcPtr;
  279.     QDPutPicUPP* = Types.UniversalProcPtr;
  280.     QDOpcodeUPP* = Types.UniversalProcPtr;
  281.     QDJShieldCursorUPP* = Types.UniversalProcPtr;
  282.  
  283.     QDProcs* = RECORD
  284.         textProc*:                QDTextUPP;
  285.         lineProc*:                QDLineUPP;
  286.         rectProc*:                QDRectUPP;
  287.         rRectProc*:                QDRRectUPP;
  288.         ovalProc*:                QDOvalUPP;
  289.         arcProc*:                QDArcUPP;
  290.         polyProc*:                QDPolyUPP;
  291.         rgnProc*:                QDRgnUPP;
  292.         bitsProc*:                QDBitsUPP;
  293.         commentProc*:            QDCommentUPP;
  294.         txMeasProc*:                QDTxMeasUPP;
  295.         getPicProc*:                QDGetPicUPP;
  296.         putPicProc*:                QDPutPicUPP;
  297.     END;
  298.  
  299.     QDProcsPtr* = POINTER TO QDProcs;
  300.  
  301. CONST
  302.     uppQDTextProcInfo* = $00003F80; (* PROCEDURE (2 byte param, 4 byte param, 4 byte param, 4 byte param); *)
  303.     uppQDLineProcInfo* = $000000C0; (* PROCEDURE (4 byte param); *)
  304.     uppQDRectProcInfo* = $00000340; (* PROCEDURE (1 byte param, 4 byte param); *)
  305.     uppQDRRectProcInfo* = $00002B40; (* PROCEDURE (1 byte param, 4 byte param, 2 byte param, 2 byte param); *)
  306.     uppQDOvalProcInfo* = $00000340; (* PROCEDURE (1 byte param, 4 byte param); *)
  307.     uppQDArcProcInfo* = $00002B40; (* PROCEDURE (1 byte param, 4 byte param, 2 byte param, 2 byte param); *)
  308.     uppQDPolyProcInfo* = $00000340; (* PROCEDURE (1 byte param, 4 byte param); *)
  309.     uppQDRgnProcInfo* = $00000340; (* PROCEDURE (1 byte param, 4 byte param); *)
  310.     uppQDBitsProcInfo* = $0000EFC0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param); *)
  311.     uppQDCommentProcInfo* = $00000E80; (* PROCEDURE (2 byte param, 2 byte param, 4 byte param); *)
  312.     uppQDTxMeasProcInfo* = $0000FFA0; (* PROCEDURE (2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; *)
  313.     uppQDGetPicProcInfo* = $000002C0; (* PROCEDURE (4 byte param, 2 byte param); *)
  314.     uppQDPutPicProcInfo* = $000002C0; (* PROCEDURE (4 byte param, 2 byte param); *)
  315.     uppQDOpcodeProcInfo* = $00002BC0; (* PROCEDURE (4 byte param, 4 byte param, 2 byte param, 2 byte param); *)
  316.     uppQDJShieldCursorProcInfo* = $00002A80; (* PROCEDURE (2 byte param, 2 byte param, 2 byte param, 2 byte param); *)
  317.  
  318. PROCEDURE NewQDTextProc*(userRoutine: QDTextProcPtr): QDTextUPP;
  319.     (*$IF NOT GENERATINGCFM *)
  320.     INLINE PASCAL $2E9F;
  321.     (*$END*)
  322.  
  323. PROCEDURE NewQDLineProc*(userRoutine: QDLineProcPtr): QDLineUPP;
  324.     (*$IF NOT GENERATINGCFM *)
  325.     INLINE PASCAL $2E9F;
  326.     (*$END*)
  327.  
  328. PROCEDURE NewQDRectProc*(userRoutine: QDRectProcPtr): QDRectUPP;
  329.     (*$IF NOT GENERATINGCFM *)
  330.     INLINE PASCAL $2E9F;
  331.     (*$END*)
  332.  
  333. PROCEDURE NewQDRRectProc*(userRoutine: QDRRectProcPtr): QDRRectUPP;
  334.     (*$IF NOT GENERATINGCFM *)
  335.     INLINE PASCAL $2E9F;
  336.     (*$END*)
  337.  
  338. PROCEDURE NewQDOvalProc*(userRoutine: QDOvalProcPtr): QDOvalUPP;
  339.     (*$IF NOT GENERATINGCFM *)
  340.     INLINE PASCAL $2E9F;
  341.     (*$END*)
  342.  
  343. PROCEDURE NewQDArcProc*(userRoutine: QDArcProcPtr): QDArcUPP;
  344.     (*$IF NOT GENERATINGCFM *)
  345.     INLINE PASCAL $2E9F;
  346.     (*$END*)
  347.  
  348. PROCEDURE NewQDPolyProc*(userRoutine: QDPolyProcPtr): QDPolyUPP;
  349.     (*$IF NOT GENERATINGCFM *)
  350.     INLINE PASCAL $2E9F;
  351.     (*$END*)
  352.  
  353. PROCEDURE NewQDRgnProc*(userRoutine: QDRgnProcPtr): QDRgnUPP;
  354.     (*$IF NOT GENERATINGCFM *)
  355.     INLINE PASCAL $2E9F;
  356.     (*$END*)
  357.  
  358. PROCEDURE NewQDBitsProc*(userRoutine: QDBitsProcPtr): QDBitsUPP;
  359.     (*$IF NOT GENERATINGCFM *)
  360.     INLINE PASCAL $2E9F;
  361.     (*$END*)
  362.  
  363. PROCEDURE NewQDCommentProc*(userRoutine: QDCommentProcPtr): QDCommentUPP;
  364.     (*$IF NOT GENERATINGCFM *)
  365.     INLINE PASCAL $2E9F;
  366.     (*$END*)
  367.  
  368. PROCEDURE NewQDTxMeasProc*(userRoutine: QDTxMeasProcPtr): QDTxMeasUPP;
  369.     (*$IF NOT GENERATINGCFM *)
  370.     INLINE PASCAL $2E9F;
  371.     (*$END*)
  372.  
  373. PROCEDURE NewQDGetPicProc*(userRoutine: QDGetPicProcPtr): QDGetPicUPP;
  374.     (*$IF NOT GENERATINGCFM *)
  375.     INLINE PASCAL $2E9F;
  376.     (*$END*)
  377.  
  378. PROCEDURE NewQDPutPicProc*(userRoutine: QDPutPicProcPtr): QDPutPicUPP;
  379.     (*$IF NOT GENERATINGCFM *)
  380.     INLINE PASCAL $2E9F;
  381.     (*$END*)
  382.  
  383. PROCEDURE NewQDOpcodeProc*(userRoutine: QDOpcodeProcPtr): QDOpcodeUPP;
  384.     (*$IF NOT GENERATINGCFM *)
  385.     INLINE PASCAL $2E9F;
  386.     (*$END*)
  387.  
  388. PROCEDURE NewQDJShieldCursorProc*(userRoutine: QDJShieldCursorProcPtr): QDJShieldCursorUPP;
  389.     (*$IF NOT GENERATINGCFM *)
  390.     INLINE PASCAL $2E9F;
  391.     (*$END*)
  392.  
  393. PROCEDURE CallQDTextProc*(byteCount: INTEGER; textBuf: Types.Ptr; numer: Types.Point; denom: Types.Point; userRoutine: QDTextUPP);
  394.     (*$IF NOT GENERATINGCFM*)
  395.     INLINE PASCAL $205F, $4E90;
  396.     (*$END*)
  397.  
  398. PROCEDURE CallQDLineProc*(newPt: Types.Point; userRoutine: QDLineUPP);
  399.     (*$IF NOT GENERATINGCFM*)
  400.     INLINE PASCAL $205F, $4E90;
  401.     (*$END*)
  402.  
  403. PROCEDURE CallQDRectProc*(verb: Types.ByteParameter; VAR r: Types.Rect; userRoutine: QDRectUPP);
  404.     (*$IF NOT GENERATINGCFM*)
  405.     INLINE PASCAL $205F, $4E90;
  406.     (*$END*)
  407.  
  408. PROCEDURE CallQDRRectProc*(verb: Types.ByteParameter; VAR r: Types.Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; userRoutine: QDRRectUPP);
  409.     (*$IF NOT GENERATINGCFM*)
  410.     INLINE PASCAL $205F, $4E90;
  411.     (*$END*)
  412.  
  413. PROCEDURE CallQDOvalProc*(verb: Types.ByteParameter; VAR r: Types.Rect; userRoutine: QDOvalUPP);
  414.     (*$IF NOT GENERATINGCFM*)
  415.     INLINE PASCAL $205F, $4E90;
  416.     (*$END*)
  417.  
  418. PROCEDURE CallQDArcProc*(verb: Types.ByteParameter; VAR r: Types.Rect; startAngle: INTEGER; arcAngle: INTEGER; userRoutine: QDArcUPP);
  419.     (*$IF NOT GENERATINGCFM*)
  420.     INLINE PASCAL $205F, $4E90;
  421.     (*$END*)
  422.  
  423. PROCEDURE CallQDPolyProc*(verb: Types.ByteParameter; poly: PolyHandle; userRoutine: QDPolyUPP);
  424.     (*$IF NOT GENERATINGCFM*)
  425.     INLINE PASCAL $205F, $4E90;
  426.     (*$END*)
  427.  
  428. PROCEDURE CallQDRgnProc*(verb: Types.ByteParameter; rgn: RgnHandle; userRoutine: QDRgnUPP);
  429.     (*$IF NOT GENERATINGCFM*)
  430.     INLINE PASCAL $205F, $4E90;
  431.     (*$END*)
  432.  
  433. PROCEDURE CallQDBitsProc*(VAR srcBits: BitMap; VAR srcRect: Types.Rect; VAR dstRect: Types.Rect; mode: INTEGER; maskRgn: RgnHandle; userRoutine: QDBitsUPP);
  434.     (*$IF NOT GENERATINGCFM*)
  435.     INLINE PASCAL $205F, $4E90;
  436.     (*$END*)
  437.  
  438. PROCEDURE CallQDCommentProc*(kind: INTEGER; dataSize: INTEGER; dataHandle: Types.Handle; userRoutine: QDCommentUPP);
  439.     (*$IF NOT GENERATINGCFM*)
  440.     INLINE PASCAL $205F, $4E90;
  441.     (*$END*)
  442.  
  443. PROCEDURE CallQDTxMeasProc*(byteCount: INTEGER; textAddr: Types.Ptr; VAR numer: Types.Point; VAR denom: Types.Point; VAR info: QuickdrawText.FontInfo; userRoutine: QDTxMeasUPP): INTEGER;
  444.     (*$IF NOT GENERATINGCFM*)
  445.     INLINE PASCAL $205F, $4E90;
  446.     (*$END*)
  447.  
  448. PROCEDURE CallQDGetPicProc*(dataPtr: Types.Ptr; byteCount: INTEGER; userRoutine: QDGetPicUPP);
  449.     (*$IF NOT GENERATINGCFM*)
  450.     INLINE PASCAL $205F, $4E90;
  451.     (*$END*)
  452.  
  453. PROCEDURE CallQDPutPicProc*(dataPtr: Types.Ptr; byteCount: INTEGER; userRoutine: QDPutPicUPP);
  454.     (*$IF NOT GENERATINGCFM*)
  455.     INLINE PASCAL $205F, $4E90;
  456.     (*$END*)
  457.  
  458. PROCEDURE CallQDOpcodeProc*(VAR fromRect: Types.Rect; VAR toRect: Types.Rect; opcode: INTEGER; version: INTEGER; userRoutine: QDOpcodeUPP);
  459.     (*$IF NOT GENERATINGCFM*)
  460.     INLINE PASCAL $205F, $4E90;
  461.     (*$END*)
  462.  
  463. PROCEDURE CallQDJShieldCursorProc*(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER; userRoutine: QDJShieldCursorUPP);
  464.     (*$IF NOT GENERATINGCFM*)
  465.     INLINE PASCAL $205F, $4E90;
  466.     (*$END*)
  467.  
  468. TYPE
  469.     GrafPort* = RECORD
  470.         device*:                    INTEGER;
  471.         portBits*:                BitMap;
  472.         portRect*:                Types.Rect;
  473.         visRgn*:                    RgnHandle;
  474.         clipRgn*:                RgnHandle;
  475.         bkPat*:                    Pattern;
  476.         fillPat*:                Pattern;
  477.         pnLoc*:                    Types.Point;
  478.         pnSize*:                    Types.Point;
  479.         pnMode*:                    INTEGER;
  480.         pnPat*:                    Pattern;
  481.         pnVis*:                    INTEGER;
  482.         txFont*:                    INTEGER;
  483.         txFace*:                    Types.Style;                                    (*txFace is unpacked byte but push as short*)
  484.         txMode*:                    INTEGER;
  485.         txSize*:                    INTEGER;
  486.         spExtra*:                Types.Fixed;
  487.         fgColor*:                LONGINT;
  488.         bkColor*:                LONGINT;
  489.         colrBit*:                INTEGER;
  490.         patStretch*:                INTEGER;
  491.         picSave*:                Types.Handle;
  492.         rgnSave*:                Types.Handle;
  493.         polySave*:                Types.Handle;
  494.         grafProcs*:                QDProcsPtr;
  495.     END;
  496.  
  497.     GrafPtr* = POINTER TO GrafPort;
  498.  
  499. (*
  500.  *    This set of definitions "belongs" in Windows.
  501.  *    But, there is a circularity in the headers where Windows includes Controls and
  502.  *    Controls includes Windows. To break the circle, the information
  503.  *    needed by Controls is moved from Windows to 
  504.  *)
  505.     WindowPtr* = GrafPtr;
  506.  
  507. (*
  508.     Set STRICT_WINDOWS to 1 to make sure your code 
  509.     doesn't access the window record directly
  510. *)
  511. (*$IF UNDEFINED STRICT_WINDOWS *)
  512. (*$SET STRICT_WINDOWS FALSE*)
  513. (*$END*)
  514. (*$IF STRICT_WINDOWS *)
  515.     WindowRef* = Types.Ptr;
  516.  
  517. (*$ELSE*)
  518.     WindowRef* = WindowPtr;
  519.  
  520. (*$END*)
  521.     DragConstraint* = Types.UInt16;
  522.  
  523.  
  524. CONST
  525.     kNoConstraint*                = 0;
  526.     kVerticalConstraint*            = 1;
  527.     kHorizontalConstraint*        = 2;
  528.  
  529. (*
  530.  *    Here ends the list of things that "belong" in Windows.
  531.  *)
  532.  
  533. TYPE
  534.     RGBColor* = RECORD
  535.         red*:                    INTEGER;                                (*magnitude of red component*)
  536.         green*:                    INTEGER;                                (*magnitude of green component*)
  537.         blue*:                    INTEGER;                                (*magnitude of blue component*)
  538.     END;
  539.  
  540.     RGBColorPtr* = POINTER TO RGBColor;
  541.     RGBColorHdl* = HANDLE TO RGBColor (*ΔΔ POINTER TO RGBColorPtr*);
  542.  
  543.     DragGrayRgnProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE ;
  544.     ColorSearchProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR rgb: RGBColor; VAR position: LONGINT): BOOLEAN;
  545.     ColorComplementProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR rgb: RGBColor): BOOLEAN;
  546.     DragGrayRgnUPP* = Types.UniversalProcPtr;
  547.     ColorSearchUPP* = Types.UniversalProcPtr;
  548.     ColorComplementUPP* = Types.UniversalProcPtr;
  549.  
  550. CONST
  551.     uppDragGrayRgnProcInfo* = $00000000; (* PROCEDURE ; *)
  552.     uppColorSearchProcInfo* = $000003D0; (* PROCEDURE (4 byte param, 4 byte param): 1 byte result; *)
  553.     uppColorComplementProcInfo* = $000000D0; (* PROCEDURE (4 byte param): 1 byte result; *)
  554.  
  555. PROCEDURE NewDragGrayRgnProc*(userRoutine: DragGrayRgnProcPtr): DragGrayRgnUPP;
  556.     (*$IF NOT GENERATINGCFM *)
  557.     INLINE PASCAL $2E9F;
  558.     (*$END*)
  559.  
  560. PROCEDURE NewColorSearchProc*(userRoutine: ColorSearchProcPtr): ColorSearchUPP;
  561.     (*$IF NOT GENERATINGCFM *)
  562.     INLINE PASCAL $2E9F;
  563.     (*$END*)
  564.  
  565. PROCEDURE NewColorComplementProc*(userRoutine: ColorComplementProcPtr): ColorComplementUPP;
  566.     (*$IF NOT GENERATINGCFM *)
  567.     INLINE PASCAL $2E9F;
  568.     (*$END*)
  569.  
  570. PROCEDURE CallDragGrayRgnProc*(userRoutine: DragGrayRgnUPP);
  571.     (*$IF NOT GENERATINGCFM*)
  572.     INLINE PASCAL $205F, $4E90;
  573.     (*$END*)
  574.  
  575. PROCEDURE CallColorSearchProc*(VAR rgb: RGBColor; VAR position: LONGINT; userRoutine: ColorSearchUPP): BOOLEAN;
  576.     (*$IF NOT GENERATINGCFM*)
  577.     INLINE PASCAL $205F, $4E90;
  578.     (*$END*)
  579.  
  580. PROCEDURE CallColorComplementProc*(VAR rgb: RGBColor; userRoutine: ColorComplementUPP): BOOLEAN;
  581.     (*$IF NOT GENERATINGCFM*)
  582.     INLINE PASCAL $205F, $4E90;
  583.     (*$END*)
  584.  
  585. TYPE
  586.     ColorSpec* = RECORD
  587.         value*:                    INTEGER;                                (*index or other value*)
  588.         rgb*:                    RGBColor;                                (*true color*)
  589.     END;
  590.  
  591.     ColorSpecPtr* = POINTER TO ColorSpec;
  592.  
  593.     CSpecArray* = ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF ColorSpec;
  594.  
  595.     xColorSpec* = RECORD
  596.         value*:                    INTEGER;                                (*index or other value*)
  597.         rgb*:                    RGBColor;                                (*true color*)
  598.         xalpha*:                    INTEGER;
  599.     END;
  600.  
  601.     xColorSpecPtr* = POINTER TO xColorSpec;
  602.  
  603.     xCSpecArray* = ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF xColorSpec;
  604.  
  605.     ColorTable* = RECORD
  606.         ctSeed*:                    LONGINT;                                (*unique identifier for table*)
  607.         ctFlags*:                INTEGER;                                (*high bit*: 0* = PixMap; 1* = device*)
  608.         ctSize*:                    INTEGER;                                (*number of entries in CTTable*)
  609.         ctTable*:                CSpecArray;                                (*array [0..0] of ColorSpec*)
  610.     END;
  611.  
  612.     CTabPtr* = POINTER TO ColorTable;
  613.     CTabHandle* = HANDLE TO ColorTable (*ΔΔ POINTER TO CTabPtr*);
  614.  
  615.     MatchRec* = RECORD
  616.         red*:                    INTEGER;
  617.         green*:                    INTEGER;
  618.         blue*:                    INTEGER;
  619.         matchData*:                LONGINT;
  620.     END;
  621.  
  622.     PixMap* = RECORD
  623.         baseAddr*:                Types.Ptr;                                    (*pointer to pixels*)
  624.         rowBytes*:                INTEGER;                                (*offset to next line*)
  625.         bounds*:                    Types.Rect;                                    (*encloses bitmap*)
  626.         pmVersion*:                INTEGER;                                (*pixMap version number*)
  627.         packType*:                INTEGER;                                (*defines packing format*)
  628.         packSize*:                LONGINT;                                (*length of pixel data*)
  629.         hRes*:                    Types.Fixed;                                    (*horiz. resolution (ppi)*)
  630.         vRes*:                    Types.Fixed;                                    (*vert. resolution (ppi)*)
  631.         pixelType*:                INTEGER;                                (*defines pixel type*)
  632.         pixelSize*:                INTEGER;                                (*# bits in pixel*)
  633.         cmpCount*:                INTEGER;                                (*# components in pixel*)
  634.         cmpSize*:                INTEGER;                                (*# bits per component*)
  635.         planeBytes*:                LONGINT;                                (*offset to next plane*)
  636.         pmTable*:                CTabHandle;                                (*color map for this pixMap*)
  637.         pmReserved*:                LONGINT;                                (*for future use. MUST BE 0*)
  638.     END;
  639.  
  640.     PixMapPtr* = POINTER TO PixMap;
  641.     PixMapHandle* = HANDLE TO PixMap (*ΔΔ POINTER TO PixMapPtr*);
  642.  
  643.     PixPat* = RECORD
  644.         patType*:                INTEGER;                                (*type of pattern*)
  645.         patMap*:                    PixMapHandle;                            (*the pattern's pixMap*)
  646.         patData*:                Types.Handle;                                    (*pixmap's data*)
  647.         patXData*:                Types.Handle;                                    (*expanded Pattern data*)
  648.         patXValid*:                INTEGER;                                (*flags whether expanded Pattern valid*)
  649.         patXMap*:                Types.Handle;                                    (*Types.Handle to expanded Pattern data*)
  650.         pat1Data*:                Pattern;                                (*old-Types.Style pattern/RGB color*)
  651.     END;
  652.  
  653.     PixPatPtr* = POINTER TO PixPat;
  654.     PixPatHandle* = HANDLE TO PixPat (*ΔΔ POINTER TO PixPatPtr*);
  655.  
  656.     CCrsr* = RECORD
  657.         crsrType*:                INTEGER;                                (*type of cursor*)
  658.         crsrMap*:                PixMapHandle;                            (*the cursor's pixmap*)
  659.         crsrData*:                Types.Handle;                                    (*cursor's data*)
  660.         crsrXData*:                Types.Handle;                                    (*expanded cursor data*)
  661.         crsrXValid*:                INTEGER;                                (*depth of expanded data (0 if none)*)
  662.         crsrXHandle*:            Types.Handle;                                    (*future use*)
  663.         crsr1Data*:                Bits16;                                    (*one-bit cursor*)
  664.         crsrMask*:                Bits16;                                    (*cursor's mask*)
  665.         crsrHotSpot*:            Types.Point;                                    (*cursor's hotspot*)
  666.         crsrXTable*:                LONGINT;                                (*private*)
  667.         crsrID*:                    LONGINT;                                (*private*)
  668.     END;
  669.  
  670.     CCrsrPtr* = POINTER TO CCrsr;
  671.     CCrsrHandle* = HANDLE TO CCrsr (*ΔΔ POINTER TO CCrsrPtr*);
  672.  
  673. (*$IF OLDROUTINELOCATIONS *)
  674.     CIcon* = RECORD
  675.         iconPMap*:                PixMap;                                    (*the icon's pixMap*)
  676.         iconMask*:                BitMap;                                    (*the icon's mask*)
  677.         iconBMap*:                BitMap;                                    (*the icon's bitMap*)
  678.         iconData*:                Types.Handle;                                    (*the icon's data*)
  679.         iconMaskData*:            ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF INTEGER;                (*icon's mask and BitMap data*)
  680.     END;
  681.  
  682.     CIconPtr* = POINTER TO CIcon;
  683.     CIconHandle* = HANDLE TO CIcon (*ΔΔ POINTER TO CIconPtr*);
  684.  
  685. (*$END*)
  686.     GammaTbl* = RECORD
  687.         gVersion*:                INTEGER;                                (*gamma version number*)
  688.         gType*:                    INTEGER;                                (*gamma data type*)
  689.         gFormulaSize*:            INTEGER;                                (*Formula data size*)
  690.         gChanCnt*:                INTEGER;                                (*number of channels of data*)
  691.         gDataCnt*:                INTEGER;                                (*number of values/channel*)
  692.         gDataWidth*:                INTEGER;                                (*bits/corrected value (data packed to next larger byte size)*)
  693.         gFormulaData*:            ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF INTEGER;                (*data for formulas followed by gamma values*)
  694.     END;
  695.  
  696.     GammaTblPtr* = POINTER TO GammaTbl;
  697.     GammaTblHandle* = HANDLE TO GammaTbl (*ΔΔ POINTER TO GammaPtr*);
  698.  
  699.     ITab* = RECORD
  700.         iTabSeed*:                LONGINT;                                (*copy of CTSeed from source CTable*)
  701.         iTabRes*:                INTEGER;                                (*bits/channel resolution of iTable*)
  702.         iTTable*:                ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF Types.SInt8; (* Types.Byte *)        (*byte colortable index values*)
  703.     END;
  704.  
  705.     ITabPtr* = POINTER TO ITab;
  706.     ITabHandle* = HANDLE TO ITab (*ΔΔ POINTER TO ITabPtr*);
  707.  
  708.     SProcRec* = RECORD
  709.         nxtSrch*:                Types.Handle;                                    (*SProcHndl Types.Handle to next SProcRec*)
  710.         srchProc*:                ColorSearchUPP;                            (*search procedure proc* ptr*)
  711.     END;
  712.  
  713.     SProcPtr* = POINTER TO SProcRec;
  714.     SProcHndl* = HANDLE TO SProcRec (*ΔΔ POINTER TO SProcPtr*);
  715.  
  716.     CProcRec* = RECORD
  717.         nxtComp*:                Types.Handle;                                    (*CProcHndl Types.Handle to next CProcRec*)
  718.         compProc*:                ColorComplementUPP;                        (*complement procedure proc* ptr*)
  719.     END;
  720.  
  721.     CProcPtr* = POINTER TO CProcRec;
  722.     CProcHndl* = HANDLE TO CProcRec (*ΔΔ POINTER TO CProcPtr*);
  723.  
  724.     GDevice* = RECORD
  725.         gdRefNum*:                INTEGER;                                (*driver's unit number*)
  726.         gdID*:                    INTEGER;                                (*client AIFF.ID for search procs*)
  727.         gdType*:                    INTEGER;                                (*fixed/CLUT/direct*)
  728.         gdITable*:                ITabHandle;                                (*Types.Handle to inverse lookup table*)
  729.         gdResPref*:                INTEGER;                                (*preferred resolution of GDITable*)
  730.         gdSearchProc*:            SProcHndl;                                (*search proc list head*)
  731.         gdCompProc*:                CProcHndl;                                (*complement proc list*)
  732.         gdFlags*:                INTEGER;                                (*grafDevice flags word*)
  733.         gdPMap*:                    PixMapHandle;                            (*describing pixMap*)
  734.         gdRefCon*:                LONGINT;                                (*reference value*)
  735.         gdNextGD*:                Types.Handle;                                    (*GDHandle Types.Handle of next gDevice*)
  736.         gdRect*:                    Types.Rect;                                    (* device's bounds in global coordinates*)
  737.         gdMode*:                    LONGINT;                                (*device's current mode*)
  738.         gdCCBytes*:                INTEGER;                                (*depth of expanded cursor data*)
  739.         gdCCDepth*:                INTEGER;                                (*depth of expanded cursor data*)
  740.         gdCCXData*:                Types.Handle;                                    (*Types.Handle to cursor's expanded data*)
  741.         gdCCXMask*:                Types.Handle;                                    (*Types.Handle to cursor's expanded mask*)
  742.         gdReserved*:                LONGINT;                                (*future use. MUST BE 0*)
  743.     END;
  744.  
  745.     GDPtr* = POINTER TO GDevice;
  746.     GDHandle* = HANDLE TO GDevice (*ΔΔ POINTER TO GDPtr*);
  747.  
  748.     GrafVars* = RECORD
  749.         rgbOpColor*:                RGBColor;                                (*color for addPin  subPin and average*)
  750.         rgbHiliteColor*:            RGBColor;                                (*color for hiliting*)
  751.         pmFgColor*:                Types.Handle;                                    (*palette Types.Handle for foreground color*)
  752.         pmFgIndex*:                INTEGER;                                (*index value for foreground*)
  753.         pmBkColor*:                Types.Handle;                                    (*palette Types.Handle for background color*)
  754.         pmBkIndex*:                INTEGER;                                (*index value for background*)
  755.         pmFlags*:                INTEGER;                                (*flags for Palettes.Palette Manager*)
  756.     END;
  757.  
  758.     GVarPtr* = POINTER TO GrafVars;
  759.     GVarHandle* = HANDLE TO GrafVars (*ΔΔ POINTER TO GVarPtr*);
  760.  
  761.     CQDProcs* = RECORD
  762.         textProc*:                QDTextUPP;
  763.         lineProc*:                QDLineUPP;
  764.         rectProc*:                QDRectUPP;
  765.         rRectProc*:                QDRRectUPP;
  766.         ovalProc*:                QDOvalUPP;
  767.         arcProc*:                QDArcUPP;
  768.         polyProc*:                QDPolyUPP;
  769.         rgnProc*:                QDRgnUPP;
  770.         bitsProc*:                QDBitsUPP;
  771.         commentProc*:            QDCommentUPP;
  772.         txMeasProc*:                QDTxMeasUPP;
  773.         getPicProc*:                QDGetPicUPP;
  774.         putPicProc*:                QDPutPicUPP;
  775.         opcodeProc*:                QDOpcodeUPP;                            (*fields added to QDProcs*)
  776.         newProc1*:                Types.UniversalProcPtr;
  777.         newProc2*:                Types.UniversalProcPtr;
  778.         newProc3*:                Types.UniversalProcPtr;
  779.         newProc4*:                Types.UniversalProcPtr;
  780.         newProc5*:                Types.UniversalProcPtr;
  781.         newProc6*:                Types.UniversalProcPtr;
  782.     END;
  783.  
  784.     CQDProcsPtr* = POINTER TO CQDProcs;
  785.  
  786.     CGrafPort* = RECORD
  787.         device*:                    INTEGER;
  788.         portPixMap*:                PixMapHandle;                            (*port's pixel map*)
  789.         portVersion*:            INTEGER;                                (*high 2 bits always set*)
  790.         grafVars*:                Types.Handle;                                    (*Types.Handle to more fields*)
  791.         chExtra*:                INTEGER;                                (*character extra*)
  792.         pnLocHFrac*:                INTEGER;                                (*pen fraction*)
  793.         portRect*:                Types.Rect;
  794.         visRgn*:                    RgnHandle;
  795.         clipRgn*:                RgnHandle;
  796.         bkPixPat*:                PixPatHandle;                            (*background pattern*)
  797.         rgbFgColor*:                RGBColor;                                (*RGB components of fg*)
  798.         rgbBkColor*:                RGBColor;                                (*RGB components of bk*)
  799.         pnLoc*:                    Types.Point;
  800.         pnSize*:                    Types.Point;
  801.         pnMode*:                    INTEGER;
  802.         pnPixPat*:                PixPatHandle;                            (*pen's pattern*)
  803.         fillPixPat*:                PixPatHandle;                            (*fill pattern*)
  804.         pnVis*:                    INTEGER;
  805.         txFont*:                    INTEGER;
  806.         txFace*:                    Types.Style;                                    (*txFace is unpacked byte  push as short*)
  807.         txMode*:                    INTEGER;
  808.         txSize*:                    INTEGER;
  809.         spExtra*:                Types.Fixed;
  810.         fgColor*:                LONGINT;
  811.         bkColor*:                LONGINT;
  812.         colrBit*:                INTEGER;
  813.         patStretch*:                INTEGER;
  814.         picSave*:                Types.Handle;
  815.         rgnSave*:                Types.Handle;
  816.         polySave*:                Types.Handle;
  817.         grafProcs*:                CQDProcsPtr;
  818.     END;
  819.  
  820.     CGrafPtr* = POINTER TO CGrafPort;
  821.  
  822.     CWindowPtr* = CGrafPtr;
  823.  
  824.     ReqListRec* = RECORD
  825.         reqLSize*:                INTEGER;                                (*request list size*)
  826.         reqLData*:                ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF INTEGER;                (*request list data*)
  827.     END;
  828.  
  829.     OpenCPicParams* = RECORD
  830.         srcRect*:                Types.Rect;
  831.         hRes*:                    Types.Fixed;
  832.         vRes*:                    Types.Fixed;
  833.         version*:                INTEGER;
  834.         reserved1*:                INTEGER;
  835.         reserved2*:                LONGINT;
  836.     END;
  837.  
  838.     CursorImageRec* = RECORD
  839.         majorVersion*:            Types.UInt16;
  840.         minorVersion*:            Types.UInt16;
  841.         cursorPixMap*:            PixMapHandle;
  842.         cursorBitMask*:            BitMapHandle;
  843.     END;
  844.  
  845.     CursorImagePtr* = POINTER TO CursorImageRec;
  846.  
  847.     DeviceLoopDrawingProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT);
  848.     DeviceLoopDrawingUPP* = Types.UniversalProcPtr;
  849.  
  850. CONST
  851.     uppDeviceLoopDrawingProcInfo* = $00003E80; (* PROCEDURE (2 byte param, 2 byte param, 4 byte param, 4 byte param); *)
  852.  
  853. PROCEDURE NewDeviceLoopDrawingProc*(userRoutine: DeviceLoopDrawingProcPtr): DeviceLoopDrawingUPP;
  854.     (*$IF NOT GENERATINGCFM *)
  855.     INLINE PASCAL $2E9F;
  856.     (*$END*)
  857.  
  858. PROCEDURE CallDeviceLoopDrawingProc*(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT; userRoutine: DeviceLoopDrawingUPP);
  859.     (*$IF NOT GENERATINGCFM*)
  860.     INLINE PASCAL $205F, $4E90;
  861.     (*$END*)
  862.  
  863. TYPE
  864.     QDGlobals* = RECORD
  865.         privates*:                (*ΔΔPACKEDΔΔ*) ARRAY 76 (*ΔΔ[0..75]ΔΔ*) OF CHAR;
  866.         randSeed*:                LONGINT;
  867.         screenBits*:                BitMap;
  868.         arrow*:                    Cursor;
  869.         dkGray*:                    Pattern;
  870.         ltGray*:                    Pattern;
  871.         gray*:                    Pattern;
  872.         black*:                    Pattern;
  873.         white*:                    Pattern;
  874.         thePort*:                GrafPtr;
  875.     END;
  876.  
  877.     QDGlobalsPtr* = POINTER TO QDGlobals;
  878.     QDGlobalsHdl* = HANDLE TO QDGlobals (*ΔΔ POINTER TO QDGlobalsPtr*);
  879.  
  880.  
  881. (* To be in sync with the C interface to QuickDraw globals, pascal code must now *)
  882. (* qualify the QuickDraw globals with “qd.” (e.g. InitGraf(.qd.thePort);  )       *)
  883. VAR
  884.     (*$PUSH*)
  885.     (*$J+*)
  886.     qd*: QDGlobals;
  887.     (*$POP*)
  888.  
  889. PROCEDURE InitGraf*(globalPtr: (*ΔΔ (*ΔΔUNIVΔΔ*)*) Types.Ptr);
  890.     (*$IF NOT GENERATINGCFM*)
  891.     INLINE PASCAL $A86E;
  892.     (*$END*)
  893. PROCEDURE OpenPort*(port: GrafPtr);
  894.     (*$IF NOT GENERATINGCFM*)
  895.     INLINE PASCAL $A86F;
  896.     (*$END*)
  897. PROCEDURE InitPort*(port: GrafPtr);
  898.     (*$IF NOT GENERATINGCFM*)
  899.     INLINE PASCAL $A86D;
  900.     (*$END*)
  901. PROCEDURE ClosePort*(port: GrafPtr);
  902.     (*$IF NOT GENERATINGCFM*)
  903.     INLINE PASCAL $A87D;
  904.     (*$END*)
  905. PROCEDURE SetPort*(port: GrafPtr);
  906.     (*$IF NOT GENERATINGCFM*)
  907.     INLINE PASCAL $A873;
  908.     (*$END*)
  909. PROCEDURE GetPort*(VAR port: GrafPtr);
  910.     (*$IF NOT GENERATINGCFM*)
  911.     INLINE PASCAL $A874;
  912.     (*$END*)
  913. PROCEDURE GrafDevice*(device: INTEGER);
  914.     (*$IF NOT GENERATINGCFM*)
  915.     INLINE PASCAL $A872;
  916.     (*$END*)
  917. PROCEDURE SetPortBits*((*CONST*)VAR bm: BitMap);
  918.     (*$IF NOT GENERATINGCFM*)
  919.     INLINE PASCAL $A875;
  920.     (*$END*)
  921. PROCEDURE PortSize*(width: INTEGER; height: INTEGER);
  922.     (*$IF NOT GENERATINGCFM*)
  923.     INLINE PASCAL $A876;
  924.     (*$END*)
  925. PROCEDURE MovePortTo*(leftGlobal: INTEGER; topGlobal: INTEGER);
  926.     (*$IF NOT GENERATINGCFM*)
  927.     INLINE PASCAL $A877;
  928.     (*$END*)
  929. PROCEDURE SetOrigin*(h: INTEGER; v: INTEGER);
  930.     (*$IF NOT GENERATINGCFM*)
  931.     INLINE PASCAL $A878;
  932.     (*$END*)
  933. PROCEDURE SetClip*(rgn: RgnHandle);
  934.     (*$IF NOT GENERATINGCFM*)
  935.     INLINE PASCAL $A879;
  936.     (*$END*)
  937. PROCEDURE GetClip*(rgn: RgnHandle);
  938.     (*$IF NOT GENERATINGCFM*)
  939.     INLINE PASCAL $A87A;
  940.     (*$END*)
  941. PROCEDURE ClipRect*((*CONST*)VAR r: Types.Rect);
  942.     (*$IF NOT GENERATINGCFM*)
  943.     INLINE PASCAL $A87B;
  944.     (*$END*)
  945. PROCEDURE BackPat*((*CONST*)VAR pat: Pattern);
  946.     (*$IF NOT GENERATINGCFM*)
  947.     INLINE PASCAL $A87C;
  948.     (*$END*)
  949. PROCEDURE InitCursor*;
  950.     (*$IF NOT GENERATINGCFM*)
  951.     INLINE PASCAL $A850;
  952.     (*$END*)
  953. PROCEDURE SetCursor*((*CONST*)VAR crsr: Cursor);
  954.     (*$IF NOT GENERATINGCFM*)
  955.     INLINE PASCAL $A851;
  956.     (*$END*)
  957. PROCEDURE HideCursor*;
  958.     (*$IF NOT GENERATINGCFM*)
  959.     INLINE PASCAL $A852;
  960.     (*$END*)
  961. PROCEDURE ShowCursor*;
  962.     (*$IF NOT GENERATINGCFM*)
  963.     INLINE PASCAL $A853;
  964.     (*$END*)
  965. PROCEDURE ObscureCursor*;
  966.     (*$IF NOT GENERATINGCFM*)
  967.     INLINE PASCAL $A856;
  968.     (*$END*)
  969. PROCEDURE HidePen*;
  970.     (*$IF NOT GENERATINGCFM*)
  971.     INLINE PASCAL $A896;
  972.     (*$END*)
  973. PROCEDURE ShowPen*;
  974.     (*$IF NOT GENERATINGCFM*)
  975.     INLINE PASCAL $A897;
  976.     (*$END*)
  977. PROCEDURE GetPen*(VAR pt: Types.Point);
  978.     (*$IF NOT GENERATINGCFM*)
  979.     INLINE PASCAL $A89A;
  980.     (*$END*)
  981. PROCEDURE GetPenState*(VAR pnState: PenState);
  982.     (*$IF NOT GENERATINGCFM*)
  983.     INLINE PASCAL $A898;
  984.     (*$END*)
  985. PROCEDURE SetPenState*((*CONST*)VAR pnState: PenState);
  986.     (*$IF NOT GENERATINGCFM*)
  987.     INLINE PASCAL $A899;
  988.     (*$END*)
  989. PROCEDURE PenSize*(width: INTEGER; height: INTEGER);
  990.     (*$IF NOT GENERATINGCFM*)
  991.     INLINE PASCAL $A89B;
  992.     (*$END*)
  993. PROCEDURE PenMode*(mode: INTEGER);
  994.     (*$IF NOT GENERATINGCFM*)
  995.     INLINE PASCAL $A89C;
  996.     (*$END*)
  997. PROCEDURE PenPat*((*CONST*)VAR pat: Pattern);
  998.     (*$IF NOT GENERATINGCFM*)
  999.     INLINE PASCAL $A89D;
  1000.     (*$END*)
  1001. PROCEDURE PenNormal*;
  1002.     (*$IF NOT GENERATINGCFM*)
  1003.     INLINE PASCAL $A89E;
  1004.     (*$END*)
  1005. PROCEDURE MoveTo*(h: INTEGER; v: INTEGER);
  1006.     (*$IF NOT GENERATINGCFM*)
  1007.     INLINE PASCAL $A893;
  1008.     (*$END*)
  1009. PROCEDURE Move*(dh: INTEGER; dv: INTEGER);
  1010.     (*$IF NOT GENERATINGCFM*)
  1011.     INLINE PASCAL $A894;
  1012.     (*$END*)
  1013. PROCEDURE LineTo*(h: INTEGER; v: INTEGER);
  1014.     (*$IF NOT GENERATINGCFM*)
  1015.     INLINE PASCAL $A891;
  1016.     (*$END*)
  1017. PROCEDURE Line*(dh: INTEGER; dv: INTEGER);
  1018.     (*$IF NOT GENERATINGCFM*)
  1019.     INLINE PASCAL $A892;
  1020.     (*$END*)
  1021. PROCEDURE ForeColor*(color: LONGINT);
  1022.     (*$IF NOT GENERATINGCFM*)
  1023.     INLINE PASCAL $A862;
  1024.     (*$END*)
  1025. PROCEDURE BackColor*(color: LONGINT);
  1026.     (*$IF NOT GENERATINGCFM*)
  1027.     INLINE PASCAL $A863;
  1028.     (*$END*)
  1029. PROCEDURE ColorBit*(whichBit: INTEGER);
  1030.     (*$IF NOT GENERATINGCFM*)
  1031.     INLINE PASCAL $A864;
  1032.     (*$END*)
  1033. PROCEDURE SetRect*(VAR r: Types.Rect; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1034.     (*$IF NOT GENERATINGCFM*)
  1035.     INLINE PASCAL $A8A7;
  1036.     (*$END*)
  1037. PROCEDURE OffsetRect*(VAR r: Types.Rect; dh: INTEGER; dv: INTEGER);
  1038.     (*$IF NOT GENERATINGCFM*)
  1039.     INLINE PASCAL $A8A8;
  1040.     (*$END*)
  1041. PROCEDURE InsetRect*(VAR r: Types.Rect; dh: INTEGER; dv: INTEGER);
  1042.     (*$IF NOT GENERATINGCFM*)
  1043.     INLINE PASCAL $A8A9;
  1044.     (*$END*)
  1045. PROCEDURE SectRect*((*CONST*)VAR src1: Types.Rect; (*CONST*)VAR src2: Types.Rect; VAR dstRect: Types.Rect): BOOLEAN;
  1046.     (*$IF NOT GENERATINGCFM*)
  1047.     INLINE PASCAL $A8AA;
  1048.     (*$END*)
  1049. PROCEDURE UnionRect*((*CONST*)VAR src1: Types.Rect; (*CONST*)VAR src2: Types.Rect; VAR dstRect: Types.Rect);
  1050.     (*$IF NOT GENERATINGCFM*)
  1051.     INLINE PASCAL $A8AB;
  1052.     (*$END*)
  1053. PROCEDURE EqualRect*((*CONST*)VAR rect1: Types.Rect; (*CONST*)VAR rect2: Types.Rect): BOOLEAN;
  1054.     (*$IF NOT GENERATINGCFM*)
  1055.     INLINE PASCAL $A8A6;
  1056.     (*$END*)
  1057. PROCEDURE EmptyRect*((*CONST*)VAR r: Types.Rect): BOOLEAN;
  1058.     (*$IF NOT GENERATINGCFM*)
  1059.     INLINE PASCAL $A8AE;
  1060.     (*$END*)
  1061. PROCEDURE FrameRect*((*CONST*)VAR r: Types.Rect);
  1062.     (*$IF NOT GENERATINGCFM*)
  1063.     INLINE PASCAL $A8A1;
  1064.     (*$END*)
  1065. PROCEDURE PaintRect*((*CONST*)VAR r: Types.Rect);
  1066.     (*$IF NOT GENERATINGCFM*)
  1067.     INLINE PASCAL $A8A2;
  1068.     (*$END*)
  1069. PROCEDURE EraseRect*((*CONST*)VAR r: Types.Rect);
  1070.     (*$IF NOT GENERATINGCFM*)
  1071.     INLINE PASCAL $A8A3;
  1072.     (*$END*)
  1073. PROCEDURE InvertRect*((*CONST*)VAR r: Types.Rect);
  1074.     (*$IF NOT GENERATINGCFM*)
  1075.     INLINE PASCAL $A8A4;
  1076.     (*$END*)
  1077. PROCEDURE FillRect*((*CONST*)VAR r: Types.Rect; (*CONST*)VAR pat: Pattern);
  1078.     (*$IF NOT GENERATINGCFM*)
  1079.     INLINE PASCAL $A8A5;
  1080.     (*$END*)
  1081. PROCEDURE FrameOval*((*CONST*)VAR r: Types.Rect);
  1082.     (*$IF NOT GENERATINGCFM*)
  1083.     INLINE PASCAL $A8B7;
  1084.     (*$END*)
  1085. PROCEDURE PaintOval*((*CONST*)VAR r: Types.Rect);
  1086.     (*$IF NOT GENERATINGCFM*)
  1087.     INLINE PASCAL $A8B8;
  1088.     (*$END*)
  1089. PROCEDURE EraseOval*((*CONST*)VAR r: Types.Rect);
  1090.     (*$IF NOT GENERATINGCFM*)
  1091.     INLINE PASCAL $A8B9;
  1092.     (*$END*)
  1093. PROCEDURE InvertOval*((*CONST*)VAR r: Types.Rect);
  1094.     (*$IF NOT GENERATINGCFM*)
  1095.     INLINE PASCAL $A8BA;
  1096.     (*$END*)
  1097. PROCEDURE FillOval*((*CONST*)VAR r: Types.Rect; (*CONST*)VAR pat: Pattern);
  1098.     (*$IF NOT GENERATINGCFM*)
  1099.     INLINE PASCAL $A8BB;
  1100.     (*$END*)
  1101. PROCEDURE FrameRoundRect*((*CONST*)VAR r: Types.Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1102.     (*$IF NOT GENERATINGCFM*)
  1103.     INLINE PASCAL $A8B0;
  1104.     (*$END*)
  1105. PROCEDURE PaintRoundRect*((*CONST*)VAR r: Types.Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1106.     (*$IF NOT GENERATINGCFM*)
  1107.     INLINE PASCAL $A8B1;
  1108.     (*$END*)
  1109. PROCEDURE EraseRoundRect*((*CONST*)VAR r: Types.Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1110.     (*$IF NOT GENERATINGCFM*)
  1111.     INLINE PASCAL $A8B2;
  1112.     (*$END*)
  1113. PROCEDURE InvertRoundRect*((*CONST*)VAR r: Types.Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1114.     (*$IF NOT GENERATINGCFM*)
  1115.     INLINE PASCAL $A8B3;
  1116.     (*$END*)
  1117. PROCEDURE FillRoundRect*((*CONST*)VAR r: Types.Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; (*CONST*)VAR pat: Pattern);
  1118.     (*$IF NOT GENERATINGCFM*)
  1119.     INLINE PASCAL $A8B4;
  1120.     (*$END*)
  1121. PROCEDURE FrameArc*((*CONST*)VAR r: Types.Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1122.     (*$IF NOT GENERATINGCFM*)
  1123.     INLINE PASCAL $A8BE;
  1124.     (*$END*)
  1125. PROCEDURE PaintArc*((*CONST*)VAR r: Types.Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1126.     (*$IF NOT GENERATINGCFM*)
  1127.     INLINE PASCAL $A8BF;
  1128.     (*$END*)
  1129. PROCEDURE EraseArc*((*CONST*)VAR r: Types.Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1130.     (*$IF NOT GENERATINGCFM*)
  1131.     INLINE PASCAL $A8C0;
  1132.     (*$END*)
  1133. PROCEDURE InvertArc*((*CONST*)VAR r: Types.Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1134.     (*$IF NOT GENERATINGCFM*)
  1135.     INLINE PASCAL $A8C1;
  1136.     (*$END*)
  1137. PROCEDURE FillArc*((*CONST*)VAR r: Types.Rect; startAngle: INTEGER; arcAngle: INTEGER; (*CONST*)VAR pat: Pattern);
  1138.     (*$IF NOT GENERATINGCFM*)
  1139.     INLINE PASCAL $A8C2;
  1140.     (*$END*)
  1141. PROCEDURE NewRgn*(): RgnHandle;
  1142.     (*$IF NOT GENERATINGCFM*)
  1143.     INLINE PASCAL $A8D8;
  1144.     (*$END*)
  1145. PROCEDURE OpenRgn*;
  1146.     (*$IF NOT GENERATINGCFM*)
  1147.     INLINE PASCAL $A8DA;
  1148.     (*$END*)
  1149. PROCEDURE CloseRgn*(dstRgn: RgnHandle);
  1150.     (*$IF NOT GENERATINGCFM*)
  1151.     INLINE PASCAL $A8DB;
  1152.     (*$END*)
  1153. (*$IF NOT SystemSevenOrLater *)
  1154. PROCEDURE BitMapToRegionGlue*(region: RgnHandle; (*CONST*)VAR bMap: BitMap): Types.OSErr;
  1155.     EXTERNAL PASCAL;
  1156. (*$END*)
  1157. PROCEDURE BitMapToRegion*(region: RgnHandle; (*CONST*)VAR bMap: BitMap): Types.OSErr;
  1158.     (*$IF NOT GENERATINGCFM*)
  1159.     INLINE PASCAL $A8D7;
  1160.     (*$END*)
  1161. PROCEDURE DisposeRgn*(rgn: RgnHandle);
  1162.     (*$IF NOT GENERATINGCFM*)
  1163.     INLINE PASCAL $A8D9;
  1164.     (*$END*)
  1165. PROCEDURE CopyRgn*(srcRgn: RgnHandle; dstRgn: RgnHandle);
  1166.     (*$IF NOT GENERATINGCFM*)
  1167.     INLINE PASCAL $A8DC;
  1168.     (*$END*)
  1169. PROCEDURE SetEmptyRgn*(rgn: RgnHandle);
  1170.     (*$IF NOT GENERATINGCFM*)
  1171.     INLINE PASCAL $A8DD;
  1172.     (*$END*)
  1173. PROCEDURE SetRectRgn*(rgn: RgnHandle; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1174.     (*$IF NOT GENERATINGCFM*)
  1175.     INLINE PASCAL $A8DE;
  1176.     (*$END*)
  1177. PROCEDURE RectRgn*(rgn: RgnHandle; (*CONST*)VAR r: Types.Rect);
  1178.     (*$IF NOT GENERATINGCFM*)
  1179.     INLINE PASCAL $A8DF;
  1180.     (*$END*)
  1181. PROCEDURE OffsetRgn*(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1182.     (*$IF NOT GENERATINGCFM*)
  1183.     INLINE PASCAL $A8E0;
  1184.     (*$END*)
  1185. PROCEDURE InsetRgn*(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1186.     (*$IF NOT GENERATINGCFM*)
  1187.     INLINE PASCAL $A8E1;
  1188.     (*$END*)
  1189. PROCEDURE SectRgn*(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1190.     (*$IF NOT GENERATINGCFM*)
  1191.     INLINE PASCAL $A8E4;
  1192.     (*$END*)
  1193. PROCEDURE UnionRgn*(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1194.     (*$IF NOT GENERATINGCFM*)
  1195.     INLINE PASCAL $A8E5;
  1196.     (*$END*)
  1197. PROCEDURE DiffRgn*(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1198.     (*$IF NOT GENERATINGCFM*)
  1199.     INLINE PASCAL $A8E6;
  1200.     (*$END*)
  1201. PROCEDURE XorRgn*(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1202.     (*$IF NOT GENERATINGCFM*)
  1203.     INLINE PASCAL $A8E7;
  1204.     (*$END*)
  1205. PROCEDURE RectInRgn*((*CONST*)VAR r: Types.Rect; rgn: RgnHandle): BOOLEAN;
  1206.     (*$IF NOT GENERATINGCFM*)
  1207.     INLINE PASCAL $A8E9;
  1208.     (*$END*)
  1209. PROCEDURE EqualRgn*(rgnA: RgnHandle; rgnB: RgnHandle): BOOLEAN;
  1210.     (*$IF NOT GENERATINGCFM*)
  1211.     INLINE PASCAL $A8E3;
  1212.     (*$END*)
  1213. PROCEDURE EmptyRgn*(rgn: RgnHandle): BOOLEAN;
  1214.     (*$IF NOT GENERATINGCFM*)
  1215.     INLINE PASCAL $A8E2;
  1216.     (*$END*)
  1217. PROCEDURE FrameRgn*(rgn: RgnHandle);
  1218.     (*$IF NOT GENERATINGCFM*)
  1219.     INLINE PASCAL $A8D2;
  1220.     (*$END*)
  1221. PROCEDURE PaintRgn*(rgn: RgnHandle);
  1222.     (*$IF NOT GENERATINGCFM*)
  1223.     INLINE PASCAL $A8D3;
  1224.     (*$END*)
  1225. PROCEDURE EraseRgn*(rgn: RgnHandle);
  1226.     (*$IF NOT GENERATINGCFM*)
  1227.     INLINE PASCAL $A8D4;
  1228.     (*$END*)
  1229. PROCEDURE InvertRgn*(rgn: RgnHandle);
  1230.     (*$IF NOT GENERATINGCFM*)
  1231.     INLINE PASCAL $A8D5;
  1232.     (*$END*)
  1233. PROCEDURE FillRgn*(rgn: RgnHandle; (*CONST*)VAR pat: Pattern);
  1234.     (*$IF NOT GENERATINGCFM*)
  1235.     INLINE PASCAL $A8D6;
  1236.     (*$END*)
  1237. PROCEDURE ScrollRect*((*CONST*)VAR r: Types.Rect; dh: INTEGER; dv: INTEGER; updateRgn: RgnHandle);
  1238.     (*$IF NOT GENERATINGCFM*)
  1239.     INLINE PASCAL $A8EF;
  1240.     (*$END*)
  1241. PROCEDURE CopyBits*((*CONST*)VAR srcBits: BitMap; (*CONST*)VAR dstBits: BitMap; (*CONST*)VAR srcRect: Types.Rect; (*CONST*)VAR dstRect: Types.Rect; mode: INTEGER; maskRgn: RgnHandle);
  1242.     (*$IF NOT GENERATINGCFM*)
  1243.     INLINE PASCAL $A8EC;
  1244.     (*$END*)
  1245. PROCEDURE SeedFill*(srcPtr: (*ΔΔ (*ΔΔUNIVΔΔ*)*) Types.Ptr; dstPtr: (*ΔΔ (*ΔΔUNIVΔΔ*)*) Types.Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER; seedH: INTEGER; seedV: INTEGER);
  1246.     (*$IF NOT GENERATINGCFM*)
  1247.     INLINE PASCAL $A839;
  1248.     (*$END*)
  1249. PROCEDURE CalcMask*(srcPtr: (*ΔΔ (*ΔΔUNIVΔΔ*)*) Types.Ptr; dstPtr: (*ΔΔ (*ΔΔUNIVΔΔ*)*) Types.Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER);
  1250.     (*$IF NOT GENERATINGCFM*)
  1251.     INLINE PASCAL $A838;
  1252.     (*$END*)
  1253. PROCEDURE CopyMask*((*CONST*)VAR srcBits: BitMap; (*CONST*)VAR maskBits: BitMap; (*CONST*)VAR dstBits: BitMap; (*CONST*)VAR srcRect: Types.Rect; (*CONST*)VAR maskRect: Types.Rect; (*CONST*)VAR dstRect: Types.Rect);
  1254.     (*$IF NOT GENERATINGCFM*)
  1255.     INLINE PASCAL $A817;
  1256.     (*$END*)
  1257. PROCEDURE OpenPicture*((*CONST*)VAR picFrame: Types.Rect): PicHandle;
  1258.     (*$IF NOT GENERATINGCFM*)
  1259.     INLINE PASCAL $A8F3;
  1260.     (*$END*)
  1261. PROCEDURE PicComment*(kind: INTEGER; dataSize: INTEGER; dataHandle: Types.Handle);
  1262.     (*$IF NOT GENERATINGCFM*)
  1263.     INLINE PASCAL $A8F2;
  1264.     (*$END*)
  1265. PROCEDURE ClosePicture*;
  1266.     (*$IF NOT GENERATINGCFM*)
  1267.     INLINE PASCAL $A8F4;
  1268.     (*$END*)
  1269. PROCEDURE DrawPicture*(myPicture: PicHandle; (*CONST*)VAR dstRect: Types.Rect);
  1270.     (*$IF NOT GENERATINGCFM*)
  1271.     INLINE PASCAL $A8F6;
  1272.     (*$END*)
  1273. PROCEDURE KillPicture*(myPicture: PicHandle);
  1274.     (*$IF NOT GENERATINGCFM*)
  1275.     INLINE PASCAL $A8F5;
  1276.     (*$END*)
  1277. PROCEDURE OpenPoly*(): PolyHandle;
  1278.     (*$IF NOT GENERATINGCFM*)
  1279.     INLINE PASCAL $A8CB;
  1280.     (*$END*)
  1281. PROCEDURE ClosePoly*;
  1282.     (*$IF NOT GENERATINGCFM*)
  1283.     INLINE PASCAL $A8CC;
  1284.     (*$END*)
  1285. PROCEDURE KillPoly*(poly: PolyHandle);
  1286.     (*$IF NOT GENERATINGCFM*)
  1287.     INLINE PASCAL $A8CD;
  1288.     (*$END*)
  1289. PROCEDURE OffsetPoly*(poly: PolyHandle; dh: INTEGER; dv: INTEGER);
  1290.     (*$IF NOT GENERATINGCFM*)
  1291.     INLINE PASCAL $A8CE;
  1292.     (*$END*)
  1293. PROCEDURE FramePoly*(poly: PolyHandle);
  1294.     (*$IF NOT GENERATINGCFM*)
  1295.     INLINE PASCAL $A8C6;
  1296.     (*$END*)
  1297. PROCEDURE PaintPoly*(poly: PolyHandle);
  1298.     (*$IF NOT GENERATINGCFM*)
  1299.     INLINE PASCAL $A8C7;
  1300.     (*$END*)
  1301. PROCEDURE ErasePoly*(poly: PolyHandle);
  1302.     (*$IF NOT GENERATINGCFM*)
  1303.     INLINE PASCAL $A8C8;
  1304.     (*$END*)
  1305. PROCEDURE InvertPoly*(poly: PolyHandle);
  1306.     (*$IF NOT GENERATINGCFM*)
  1307.     INLINE PASCAL $A8C9;
  1308.     (*$END*)
  1309. PROCEDURE FillPoly*(poly: PolyHandle; (*CONST*)VAR pat: Pattern);
  1310.     (*$IF NOT GENERATINGCFM*)
  1311.     INLINE PASCAL $A8CA;
  1312.     (*$END*)
  1313. PROCEDURE SetPt*(VAR pt: Types.Point; h: INTEGER; v: INTEGER);
  1314.     (*$IF NOT GENERATINGCFM*)
  1315.     INLINE PASCAL $A880;
  1316.     (*$END*)
  1317. PROCEDURE LocalToGlobal*(VAR pt: Types.Point);
  1318.     (*$IF NOT GENERATINGCFM*)
  1319.     INLINE PASCAL $A870;
  1320.     (*$END*)
  1321. PROCEDURE GlobalToLocal*(VAR pt: Types.Point);
  1322.     (*$IF NOT GENERATINGCFM*)
  1323.     INLINE PASCAL $A871;
  1324.     (*$END*)
  1325. PROCEDURE Random*(): INTEGER;
  1326.     (*$IF NOT GENERATINGCFM*)
  1327.     INLINE PASCAL $A861;
  1328.     (*$END*)
  1329. PROCEDURE StuffHex*(thingPtr: (*ΔΔUNIVΔΔ*) Types.Ptr; s: Types.ConstStr255Param);
  1330.     (*$IF NOT GENERATINGCFM*)
  1331.     INLINE PASCAL $A866;
  1332.     (*$END*)
  1333. PROCEDURE GetPixel*(h: INTEGER; v: INTEGER): BOOLEAN;
  1334.     (*$IF NOT GENERATINGCFM*)
  1335.     INLINE PASCAL $A865;
  1336.     (*$END*)
  1337. PROCEDURE ScalePt*(VAR pt: Types.Point; (*CONST*)VAR srcRect: Types.Rect; (*CONST*)VAR dstRect: Types.Rect);
  1338.     (*$IF NOT GENERATINGCFM*)
  1339.     INLINE PASCAL $A8F8;
  1340.     (*$END*)
  1341. PROCEDURE MapPt*(VAR pt: Types.Point; (*CONST*)VAR srcRect: Types.Rect; (*CONST*)VAR dstRect: Types.Rect);
  1342.     (*$IF NOT GENERATINGCFM*)
  1343.     INLINE PASCAL $A8F9;
  1344.     (*$END*)
  1345. PROCEDURE MapRect*(VAR r: Types.Rect; (*CONST*)VAR srcRect: Types.Rect; (*CONST*)VAR dstRect: Types.Rect);
  1346.     (*$IF NOT GENERATINGCFM*)
  1347.     INLINE PASCAL $A8FA;
  1348.     (*$END*)
  1349. PROCEDURE MapRgn*(rgn: RgnHandle; (*CONST*)VAR srcRect: Types.Rect; (*CONST*)VAR dstRect: Types.Rect);
  1350.     (*$IF NOT GENERATINGCFM*)
  1351.     INLINE PASCAL $A8FB;
  1352.     (*$END*)
  1353. PROCEDURE MapPoly*(poly: PolyHandle; (*CONST*)VAR srcRect: Types.Rect; (*CONST*)VAR dstRect: Types.Rect);
  1354.     (*$IF NOT GENERATINGCFM*)
  1355.     INLINE PASCAL $A8FC;
  1356.     (*$END*)
  1357. PROCEDURE SetStdProcs*(VAR procs: QDProcs);
  1358.     (*$IF NOT GENERATINGCFM*)
  1359.     INLINE PASCAL $A8EA;
  1360.     (*$END*)
  1361. PROCEDURE StdRect*(verb: Types.ByteParameter; (*CONST*)VAR r: Types.Rect);
  1362.     (*$IF NOT GENERATINGCFM*)
  1363.     INLINE PASCAL $A8A0;
  1364.     (*$END*)
  1365. PROCEDURE StdRRect*(verb: Types.ByteParameter; (*CONST*)VAR r: Types.Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1366.     (*$IF NOT GENERATINGCFM*)
  1367.     INLINE PASCAL $A8AF;
  1368.     (*$END*)
  1369. PROCEDURE StdOval*(verb: Types.ByteParameter; (*CONST*)VAR r: Types.Rect);
  1370.     (*$IF NOT GENERATINGCFM*)
  1371.     INLINE PASCAL $A8B6;
  1372.     (*$END*)
  1373. PROCEDURE StdArc*(verb: Types.ByteParameter; (*CONST*)VAR r: Types.Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1374.     (*$IF NOT GENERATINGCFM*)
  1375.     INLINE PASCAL $A8BD;
  1376.     (*$END*)
  1377. PROCEDURE StdPoly*(verb: Types.ByteParameter; poly: PolyHandle);
  1378.     (*$IF NOT GENERATINGCFM*)
  1379.     INLINE PASCAL $A8C5;
  1380.     (*$END*)
  1381. PROCEDURE StdRgn*(verb: Types.ByteParameter; rgn: RgnHandle);
  1382.     (*$IF NOT GENERATINGCFM*)
  1383.     INLINE PASCAL $A8D1;
  1384.     (*$END*)
  1385. PROCEDURE StdBits*((*CONST*)VAR srcBits: BitMap; (*CONST*)VAR srcRect: Types.Rect; (*CONST*)VAR dstRect: Types.Rect; mode: INTEGER; maskRgn: RgnHandle);
  1386.     (*$IF NOT GENERATINGCFM*)
  1387.     INLINE PASCAL $A8EB;
  1388.     (*$END*)
  1389. PROCEDURE StdComment*(kind: INTEGER; dataSize: INTEGER; dataHandle: Types.Handle);
  1390.     (*$IF NOT GENERATINGCFM*)
  1391.     INLINE PASCAL $A8F1;
  1392.     (*$END*)
  1393. PROCEDURE StdGetPic*(dataPtr: (*ΔΔ (*ΔΔUNIVΔΔ*)*) Types.Ptr; byteCount: INTEGER);
  1394.     (*$IF NOT GENERATINGCFM*)
  1395.     INLINE PASCAL $A8EE;
  1396.     (*$END*)
  1397. PROCEDURE StdPutPic*(dataPtr: (*ΔΔ (*ΔΔUNIVΔΔ*)*) Types.Ptr; byteCount: INTEGER);
  1398.     (*$IF NOT GENERATINGCFM*)
  1399.     INLINE PASCAL $A8F0;
  1400.     (*$END*)
  1401. PROCEDURE AddPt*(src: Types.Point; VAR dst: Types.Point);
  1402.     (*$IF NOT GENERATINGCFM*)
  1403.     INLINE PASCAL $A87E;
  1404.     (*$END*)
  1405. PROCEDURE EqualPt*(pt1: Types.Point; pt2: Types.Point): BOOLEAN;
  1406.     (*$IF NOT GENERATINGCFM*)
  1407.     INLINE PASCAL $A881;
  1408.     (*$END*)
  1409. PROCEDURE PtInRect*(pt: Types.Point; (*CONST*)VAR r: Types.Rect): BOOLEAN;
  1410.     (*$IF NOT GENERATINGCFM*)
  1411.     INLINE PASCAL $A8AD;
  1412.     (*$END*)
  1413. PROCEDURE Pt2Rect*(pt1: Types.Point; pt2: Types.Point; VAR dstRect: Types.Rect);
  1414.     (*$IF NOT GENERATINGCFM*)
  1415.     INLINE PASCAL $A8AC;
  1416.     (*$END*)
  1417. PROCEDURE PtToAngle*((*CONST*)VAR r: Types.Rect; pt: Types.Point; VAR angle: INTEGER);
  1418.     (*$IF NOT GENERATINGCFM*)
  1419.     INLINE PASCAL $A8C3;
  1420.     (*$END*)
  1421. PROCEDURE SubPt*(src: Types.Point; VAR dst: Types.Point);
  1422.     (*$IF NOT GENERATINGCFM*)
  1423.     INLINE PASCAL $A87F;
  1424.     (*$END*)
  1425. PROCEDURE PtInRgn*(pt: Types.Point; rgn: RgnHandle): BOOLEAN;
  1426.     (*$IF NOT GENERATINGCFM*)
  1427.     INLINE PASCAL $A8E8;
  1428.     (*$END*)
  1429. PROCEDURE StdLine*(newPt: Types.Point);
  1430.     (*$IF NOT GENERATINGCFM*)
  1431.     INLINE PASCAL $A890;
  1432.     (*$END*)
  1433. PROCEDURE OpenCPort*(port: CGrafPtr);
  1434.     (*$IF NOT GENERATINGCFM*)
  1435.     INLINE PASCAL $AA00;
  1436.     (*$END*)
  1437. PROCEDURE InitCPort*(port: CGrafPtr);
  1438.     (*$IF NOT GENERATINGCFM*)
  1439.     INLINE PASCAL $AA01;
  1440.     (*$END*)
  1441. PROCEDURE CloseCPort*(port: CGrafPtr);
  1442.     (*$IF NOT GENERATINGCFM*)
  1443.     INLINE PASCAL $A87D;
  1444.     (*$END*)
  1445. PROCEDURE NewPixMap*(): PixMapHandle;
  1446.     (*$IF NOT GENERATINGCFM*)
  1447.     INLINE PASCAL $AA03;
  1448.     (*$END*)
  1449. PROCEDURE DisposePixMap*(pm: PixMapHandle);
  1450.     (*$IF NOT GENERATINGCFM*)
  1451.     INLINE PASCAL $AA04;
  1452.     (*$END*)
  1453. PROCEDURE CopyPixMap*(srcPM: PixMapHandle; dstPM: PixMapHandle);
  1454.     (*$IF NOT GENERATINGCFM*)
  1455.     INLINE PASCAL $AA05;
  1456.     (*$END*)
  1457. PROCEDURE NewPixPat*(): PixPatHandle;
  1458.     (*$IF NOT GENERATINGCFM*)
  1459.     INLINE PASCAL $AA07;
  1460.     (*$END*)
  1461. PROCEDURE DisposePixPat*(pp: PixPatHandle);
  1462.     (*$IF NOT GENERATINGCFM*)
  1463.     INLINE PASCAL $AA08;
  1464.     (*$END*)
  1465. PROCEDURE CopyPixPat*(srcPP: PixPatHandle; dstPP: PixPatHandle);
  1466.     (*$IF NOT GENERATINGCFM*)
  1467.     INLINE PASCAL $AA09;
  1468.     (*$END*)
  1469. PROCEDURE PenPixPat*(pp: PixPatHandle);
  1470.     (*$IF NOT GENERATINGCFM*)
  1471.     INLINE PASCAL $AA0A;
  1472.     (*$END*)
  1473. PROCEDURE BackPixPat*(pp: PixPatHandle);
  1474.     (*$IF NOT GENERATINGCFM*)
  1475.     INLINE PASCAL $AA0B;
  1476.     (*$END*)
  1477. PROCEDURE GetPixPat*(patID: INTEGER): PixPatHandle;
  1478.     (*$IF NOT GENERATINGCFM*)
  1479.     INLINE PASCAL $AA0C;
  1480.     (*$END*)
  1481. PROCEDURE MakeRGBPat*(pp: PixPatHandle; (*CONST*)VAR myColor: RGBColor);
  1482.     (*$IF NOT GENERATINGCFM*)
  1483.     INLINE PASCAL $AA0D;
  1484.     (*$END*)
  1485. PROCEDURE FillCRect*((*CONST*)VAR r: Types.Rect; pp: PixPatHandle);
  1486.     (*$IF NOT GENERATINGCFM*)
  1487.     INLINE PASCAL $AA0E;
  1488.     (*$END*)
  1489. PROCEDURE FillCOval*((*CONST*)VAR r: Types.Rect; pp: PixPatHandle);
  1490.     (*$IF NOT GENERATINGCFM*)
  1491.     INLINE PASCAL $AA0F;
  1492.     (*$END*)
  1493. PROCEDURE FillCRoundRect*((*CONST*)VAR r: Types.Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; pp: PixPatHandle);
  1494.     (*$IF NOT GENERATINGCFM*)
  1495.     INLINE PASCAL $AA10;
  1496.     (*$END*)
  1497. PROCEDURE FillCArc*((*CONST*)VAR r: Types.Rect; startAngle: INTEGER; arcAngle: INTEGER; pp: PixPatHandle);
  1498.     (*$IF NOT GENERATINGCFM*)
  1499.     INLINE PASCAL $AA11;
  1500.     (*$END*)
  1501. PROCEDURE FillCRgn*(rgn: RgnHandle; pp: PixPatHandle);
  1502.     (*$IF NOT GENERATINGCFM*)
  1503.     INLINE PASCAL $AA12;
  1504.     (*$END*)
  1505. PROCEDURE FillCPoly*(poly: PolyHandle; pp: PixPatHandle);
  1506.     (*$IF NOT GENERATINGCFM*)
  1507.     INLINE PASCAL $AA13;
  1508.     (*$END*)
  1509. PROCEDURE RGBForeColor*((*CONST*)VAR color: RGBColor);
  1510.     (*$IF NOT GENERATINGCFM*)
  1511.     INLINE PASCAL $AA14;
  1512.     (*$END*)
  1513. PROCEDURE RGBBackColor*((*CONST*)VAR color: RGBColor);
  1514.     (*$IF NOT GENERATINGCFM*)
  1515.     INLINE PASCAL $AA15;
  1516.     (*$END*)
  1517. PROCEDURE SetCPixel*(h: INTEGER; v: INTEGER; (*CONST*)VAR cPix: RGBColor);
  1518.     (*$IF NOT GENERATINGCFM*)
  1519.     INLINE PASCAL $AA16;
  1520.     (*$END*)
  1521. PROCEDURE SetPortPix*(pm: PixMapHandle);
  1522.     (*$IF NOT GENERATINGCFM*)
  1523.     INLINE PASCAL $AA06;
  1524.     (*$END*)
  1525. PROCEDURE GetCPixel*(h: INTEGER; v: INTEGER; VAR cPix: RGBColor);
  1526.     (*$IF NOT GENERATINGCFM*)
  1527.     INLINE PASCAL $AA17;
  1528.     (*$END*)
  1529. PROCEDURE GetForeColor*(VAR color: RGBColor);
  1530.     (*$IF NOT GENERATINGCFM*)
  1531.     INLINE PASCAL $AA19;
  1532.     (*$END*)
  1533. PROCEDURE GetBackColor*(VAR color: RGBColor);
  1534.     (*$IF NOT GENERATINGCFM*)
  1535.     INLINE PASCAL $AA1A;
  1536.     (*$END*)
  1537. PROCEDURE SeedCFill*((*CONST*)VAR srcBits: BitMap; (*CONST*)VAR dstBits: BitMap; (*CONST*)VAR srcRect: Types.Rect; (*CONST*)VAR dstRect: Types.Rect; seedH: INTEGER; seedV: INTEGER; matchProc: ColorSearchUPP; matchData: LONGINT);
  1538.     (*$IF NOT GENERATINGCFM*)
  1539.     INLINE PASCAL $AA50;
  1540.     (*$END*)
  1541. PROCEDURE CalcCMask*((*CONST*)VAR srcBits: BitMap; (*CONST*)VAR dstBits: BitMap; (*CONST*)VAR srcRect: Types.Rect; (*CONST*)VAR dstRect: Types.Rect; (*CONST*)VAR seedRGB: RGBColor; matchProc: ColorSearchUPP; matchData: LONGINT);
  1542.     (*$IF NOT GENERATINGCFM*)
  1543.     INLINE PASCAL $AA4F;
  1544.     (*$END*)
  1545. PROCEDURE OpenCPicture*((*CONST*)VAR newHeader: OpenCPicParams): PicHandle;
  1546.     (*$IF NOT GENERATINGCFM*)
  1547.     INLINE PASCAL $AA20;
  1548.     (*$END*)
  1549. PROCEDURE OpColor*((*CONST*)VAR color: RGBColor);
  1550.     (*$IF NOT GENERATINGCFM*)
  1551.     INLINE PASCAL $AA21;
  1552.     (*$END*)
  1553. PROCEDURE HiliteColor*((*CONST*)VAR color: RGBColor);
  1554.     (*$IF NOT GENERATINGCFM*)
  1555.     INLINE PASCAL $AA22;
  1556.     (*$END*)
  1557. PROCEDURE DisposeCTable*(cTable: CTabHandle);
  1558.     (*$IF NOT GENERATINGCFM*)
  1559.     INLINE PASCAL $AA24;
  1560.     (*$END*)
  1561. PROCEDURE GetCTable*(ctID: INTEGER): CTabHandle;
  1562.     (*$IF NOT GENERATINGCFM*)
  1563.     INLINE PASCAL $AA18;
  1564.     (*$END*)
  1565. PROCEDURE GetCCursor*(crsrID: INTEGER): CCrsrHandle;
  1566.     (*$IF NOT GENERATINGCFM*)
  1567.     INLINE PASCAL $AA1B;
  1568.     (*$END*)
  1569. PROCEDURE SetCCursor*(cCrsr: CCrsrHandle);
  1570.     (*$IF NOT GENERATINGCFM*)
  1571.     INLINE PASCAL $AA1C;
  1572.     (*$END*)
  1573. PROCEDURE AllocCursor*;
  1574.     (*$IF NOT GENERATINGCFM*)
  1575.     INLINE PASCAL $AA1D;
  1576.     (*$END*)
  1577. PROCEDURE DisposeCCursor*(cCrsr: CCrsrHandle);
  1578.     (*$IF NOT GENERATINGCFM*)
  1579.     INLINE PASCAL $AA26;
  1580.     (*$END*)
  1581. (*$IF OLDROUTINELOCATIONS *)
  1582. PROCEDURE GetCIcon*(iconID: INTEGER): CIconHandle;
  1583.     (*$IF NOT GENERATINGCFM*)
  1584.     INLINE PASCAL $AA1E;
  1585.     (*$END*)
  1586. PROCEDURE PlotCIcon*((*CONST*)VAR theRect: Types.Rect; theIcon: CIconHandle);
  1587.     (*$IF NOT GENERATINGCFM*)
  1588.     INLINE PASCAL $AA1F;
  1589.     (*$END*)
  1590. PROCEDURE DisposeCIcon*(theIcon: CIconHandle);
  1591.     (*$IF NOT GENERATINGCFM*)
  1592.     INLINE PASCAL $AA25;
  1593.     (*$END*)
  1594. (*$END*)
  1595. PROCEDURE SetStdCProcs*(VAR procs: CQDProcs);
  1596.     (*$IF NOT GENERATINGCFM*)
  1597.     INLINE PASCAL $AA4E;
  1598.     (*$END*)
  1599. PROCEDURE GetMaxDevice*((*CONST*)VAR globalRect: Types.Rect): GDHandle;
  1600.     (*$IF NOT GENERATINGCFM*)
  1601.     INLINE PASCAL $AA27;
  1602.     (*$END*)
  1603. PROCEDURE GetCTSeed*(): LONGINT;
  1604.     (*$IF NOT GENERATINGCFM*)
  1605.     INLINE PASCAL $AA28;
  1606.     (*$END*)
  1607. PROCEDURE GetDeviceList*(): GDHandle;
  1608.     (*$IF NOT GENERATINGCFM*)
  1609.     INLINE PASCAL $AA29;
  1610.     (*$END*)
  1611. PROCEDURE GetMainDevice*(): GDHandle;
  1612.     (*$IF NOT GENERATINGCFM*)
  1613.     INLINE PASCAL $AA2A;
  1614.     (*$END*)
  1615. PROCEDURE GetNextDevice*(curDevice: GDHandle): GDHandle;
  1616.     (*$IF NOT GENERATINGCFM*)
  1617.     INLINE PASCAL $AA2B;
  1618.     (*$END*)
  1619. PROCEDURE TestDeviceAttribute*(gdh: GDHandle; attribute: INTEGER): BOOLEAN;
  1620.     (*$IF NOT GENERATINGCFM*)
  1621.     INLINE PASCAL $AA2C;
  1622.     (*$END*)
  1623. PROCEDURE SetDeviceAttribute*(gdh: GDHandle; attribute: INTEGER; value: BOOLEAN);
  1624.     (*$IF NOT GENERATINGCFM*)
  1625.     INLINE PASCAL $AA2D;
  1626.     (*$END*)
  1627. PROCEDURE InitGDevice*(qdRefNum: INTEGER; mode: LONGINT; gdh: GDHandle);
  1628.     (*$IF NOT GENERATINGCFM*)
  1629.     INLINE PASCAL $AA2E;
  1630.     (*$END*)
  1631. PROCEDURE NewGDevice*(refNum: INTEGER; mode: LONGINT): GDHandle;
  1632.     (*$IF NOT GENERATINGCFM*)
  1633.     INLINE PASCAL $AA2F;
  1634.     (*$END*)
  1635. PROCEDURE DisposeGDevice*(gdh: GDHandle);
  1636.     (*$IF NOT GENERATINGCFM*)
  1637.     INLINE PASCAL $AA30;
  1638.     (*$END*)
  1639. PROCEDURE SetGDevice*(gd: GDHandle);
  1640.     (*$IF NOT GENERATINGCFM*)
  1641.     INLINE PASCAL $AA31;
  1642.     (*$END*)
  1643. PROCEDURE GetGDevice*(): GDHandle;
  1644.     (*$IF NOT GENERATINGCFM*)
  1645.     INLINE PASCAL $AA32;
  1646.     (*$END*)
  1647. PROCEDURE Color2Index*((*CONST*)VAR myColor: RGBColor): LONGINT;
  1648.     (*$IF NOT GENERATINGCFM*)
  1649.     INLINE PASCAL $AA33;
  1650.     (*$END*)
  1651. PROCEDURE Index2Color*(index: LONGINT; VAR aColor: RGBColor);
  1652.     (*$IF NOT GENERATINGCFM*)
  1653.     INLINE PASCAL $AA34;
  1654.     (*$END*)
  1655. PROCEDURE InvertColor*(VAR myColor: RGBColor);
  1656.     (*$IF NOT GENERATINGCFM*)
  1657.     INLINE PASCAL $AA35;
  1658.     (*$END*)
  1659. PROCEDURE RealColor*((*CONST*)VAR color: RGBColor): BOOLEAN;
  1660.     (*$IF NOT GENERATINGCFM*)
  1661.     INLINE PASCAL $AA36;
  1662.     (*$END*)
  1663. PROCEDURE GetSubTable*(myColors: CTabHandle; iTabRes: INTEGER; targetTbl: CTabHandle);
  1664.     (*$IF NOT GENERATINGCFM*)
  1665.     INLINE PASCAL $AA37;
  1666.     (*$END*)
  1667. PROCEDURE MakeITable*(cTabH: CTabHandle; iTabH: ITabHandle; res: INTEGER);
  1668.     (*$IF NOT GENERATINGCFM*)
  1669.     INLINE PASCAL $AA39;
  1670.     (*$END*)
  1671. PROCEDURE AddSearch*(searchProc: ColorSearchUPP);
  1672.     (*$IF NOT GENERATINGCFM*)
  1673.     INLINE PASCAL $AA3A;
  1674.     (*$END*)
  1675. PROCEDURE AddComp*(compProc: ColorComplementUPP);
  1676.     (*$IF NOT GENERATINGCFM*)
  1677.     INLINE PASCAL $AA3B;
  1678.     (*$END*)
  1679. PROCEDURE DelSearch*(searchProc: ColorSearchUPP);
  1680.     (*$IF NOT GENERATINGCFM*)
  1681.     INLINE PASCAL $AA4C;
  1682.     (*$END*)
  1683. PROCEDURE DelComp*(compProc: ColorComplementUPP);
  1684.     (*$IF NOT GENERATINGCFM*)
  1685.     INLINE PASCAL $AA4D;
  1686.     (*$END*)
  1687. PROCEDURE SetClientID*(id: INTEGER);
  1688.     (*$IF NOT GENERATINGCFM*)
  1689.     INLINE PASCAL $AA3C;
  1690.     (*$END*)
  1691. PROCEDURE ProtectEntry*(index: INTEGER; protect: BOOLEAN);
  1692.     (*$IF NOT GENERATINGCFM*)
  1693.     INLINE PASCAL $AA3D;
  1694.     (*$END*)
  1695. PROCEDURE ReserveEntry*(index: INTEGER; reserve: BOOLEAN);
  1696.     (*$IF NOT GENERATINGCFM*)
  1697.     INLINE PASCAL $AA3E;
  1698.     (*$END*)
  1699. PROCEDURE SetEntries*(start: INTEGER; count: INTEGER; VAR aTable: CSpecArray);
  1700.     (*$IF NOT GENERATINGCFM*)
  1701.     INLINE PASCAL $AA3F;
  1702.     (*$END*)
  1703. PROCEDURE SaveEntries*(srcTable: CTabHandle; resultTable: CTabHandle; VAR selection: ReqListRec);
  1704.     (*$IF NOT GENERATINGCFM*)
  1705.     INLINE PASCAL $AA49;
  1706.     (*$END*)
  1707. PROCEDURE RestoreEntries*(srcTable: CTabHandle; dstTable: CTabHandle; VAR selection: ReqListRec);
  1708.     (*$IF NOT GENERATINGCFM*)
  1709.     INLINE PASCAL $AA4A;
  1710.     (*$END*)
  1711. PROCEDURE QDError*(): INTEGER;
  1712.     (*$IF NOT GENERATINGCFM*)
  1713.     INLINE PASCAL $AA40;
  1714.     (*$END*)
  1715. PROCEDURE CopyDeepMask*((*CONST*)VAR srcBits: BitMap; (*CONST*)VAR maskBits: BitMap; (*CONST*)VAR dstBits: BitMap; (*CONST*)VAR srcRect: Types.Rect; (*CONST*)VAR maskRect: Types.Rect; (*CONST*)VAR dstRect: Types.Rect; mode: INTEGER; maskRgn: RgnHandle);
  1716.     (*$IF NOT GENERATINGCFM*)
  1717.     INLINE PASCAL $AA51;
  1718.     (*$END*)
  1719. PROCEDURE DeviceLoop*(drawingRgn: RgnHandle; drawingProc: DeviceLoopDrawingUPP; userData: LONGINT; flags: DeviceLoopFlags);
  1720.     (*$IF NOT GENERATINGCFM*)
  1721.     INLINE PASCAL $ABCA;
  1722.     (*$END*)
  1723. PROCEDURE GetMaskTable*(): Types.Ptr;
  1724.     (*$IF NOT GENERATINGCFM*)
  1725.     INLINE PASCAL $A836, $2E88;
  1726.     (*$END*)
  1727. (*$IF OLDROUTINENAMES *)
  1728. PROCEDURE DisposPixMap*(pm: PixMapHandle);
  1729.     (*$IF NOT GENERATINGCFM*)
  1730.     INLINE PASCAL $AA04;
  1731.     (*$END*)
  1732. PROCEDURE DisposPixPat*(pp: PixPatHandle);
  1733.     (*$IF NOT GENERATINGCFM*)
  1734.     INLINE PASCAL $AA08;
  1735.     (*$END*)
  1736. PROCEDURE DisposCTable*(cTable: CTabHandle);
  1737.     (*$IF NOT GENERATINGCFM*)
  1738.     INLINE PASCAL $AA24;
  1739.     (*$END*)
  1740. PROCEDURE DisposCCursor*(cCrsr: CCrsrHandle);
  1741.     (*$IF NOT GENERATINGCFM*)
  1742.     INLINE PASCAL $AA26;
  1743.     (*$END*)
  1744. (*$IF OLDROUTINELOCATIONS *)
  1745. PROCEDURE DisposCIcon*(theIcon: CIconHandle);
  1746.     (*$IF NOT GENERATINGCFM*)
  1747.     INLINE PASCAL $AA25;
  1748.     (*$END*)
  1749. (*$END*)
  1750. PROCEDURE DisposGDevice*(gdh: GDHandle);
  1751.     (*$IF NOT GENERATINGCFM*)
  1752.     INLINE PASCAL $AA30;
  1753.     (*$END*)
  1754. (*$END*)
  1755.  
  1756. (* $ALIGN RESET*)
  1757. (* $POP*)
  1758.  
  1759.  END Quickdraw.
  1760.